{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Quantitative Finance\n",
    "\n",
    "Copyright (c) 2019 Python Charmers Pty Ltd, Australia, <https://pythoncharmers.com>. All rights reserved.\n",
    "\n",
    "<img src=\"img/python_charmers_logo.png\" width=\"300\" alt=\"Python Charmers Logo\">\n",
    "\n",
    "    Published under the Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0) license. See `LICENSE.md` for details.\n",
    "\n",
    "Sponsored by Tibra Global Services, <https://tibra.com>\n",
    "\n",
    "<img src=\"img/tibra_logo.png\" width=\"300\" alt=\"Tibra Logo\">\n",
    "\n",
    "\n",
    "## Module 1.4: Principle Component Analysis (PCA)\n",
    "\n",
    "### 1.4.2 PCA Interpretation\n",
    "\n",
    "In the last notebook we introduced the Principle Component Analysis algorithm - PCA. In this notebook we will look at the algorithm in more detail, including methods for analysing the results.\n",
    "\n",
    "From a linear algebra perspective, the algorithm itself is quite straightforward:\n",
    "\n",
    "1. Normalise X to have a zero mean (`X = X - np.mean(X, axis=0)`)\n",
    "2. Calculate the covariance matrix $\\Sigma$, which is a square matrix of size `k`, the number of variables, where value $\\Sigma_{i,j}$ is the covariance of variables $i$ and $j$. Note that $\\Sigma = X'X$.\n",
    "3. Find the eigenvectors of $\\Sigma$\n",
    "\n",
    "The resulting eigenvectors will be the component and the eigenvalues of those will be the relative variance explained by the given component. If you sort the eigenvectors by their eigenvalues (highest first), you get the sorted eigenvectors, giving the sorted (by importance) principle components.\n",
    "\n",
    "To compute the transformed data, perform a dot product $XC$, where $C$ is a matrix of the first $n$ components we are interested in (which could be \"all of them\" if $n=k$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run setup.ipy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "#### Exercise\n",
    "\n",
    "1. Review the documentation for the scikit-learn PCA algorithm, as well as the linked description. What does the `whiten` parameter do and when is it useful?\n",
    "\n",
    "\n",
    "#### Extended Exercise\n",
    "\n",
    "Implement the PCA algorithm as given above using only the NumPy algorithm.\n",
    "\n",
    "**Hint:** The `np.linalg.eig` function can be used for computing the eigenvectors and eigenvalues, although they won't be sorted correctly.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*For solutions, see `solutions/pca_numpy.py`*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eigenvectors and Eigenvalues\n",
    "\n",
    "Eigenvectors are an area of linear algebra that often causes lots of confusion. You *can* simply use PCA without knowing what they are. They are used within the algorithm, but the values that you normally use are the transformed dataset $X$, rather than the eigenvectors and eigenvalues themselves.\n",
    "\n",
    "However, an intuitive understanding of Eigenvectors can often help. To help with this, the following video on YouTube has the incredibly clear explanation and useful visualisations:\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/PFDu9oVAE-g\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen>\n",
    "</iframe>\n",
    "\n",
    "(If that doesn't load, which can happen due to security settings, click this link: https://www.youtube.com/watch?v=PFDu9oVAE-g )\n",
    "\n",
    "Usefully, the above video also talks about the change in basis, which is what PCA is effectively doing to your data.\n",
    "\n",
    "Details about linear algebra are outside the scope of this course, but I would recommend the full series of videos in the above playlist to fill any gaps in understanding. Also, the visualisations are written in Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Limitations of PCA\n",
    "\n",
    "PCA is not a perfect algorithm (such a thing doesn't exist), and using it has drawbacks. These are listed below:\n",
    "\n",
    "### Computation Requirements\n",
    "\n",
    "From a practical perspective, it can be very computationally heavy to undertake PCA on a dataset, particularly a large one. For this reason, methods like a [Randomised PCA](http://lijiancheng0614.github.io/scikit-learn/modules/generated/sklearn.decomposition.RandomizedPCA.html) which gives an approximation that is normally good enough practically, but takes far less computation time.\n",
    "\n",
    "\n",
    "### Sparse Representations\n",
    "\n",
    "Another limitation of PCA is that the resulting vectors from a PCA transformation are often quite dense. What this means, is that many of the values in the components are non-zero. From a mathematical perspective, this doesn't matter. However, from a computational perspective, having lots of zero elements in a vector allows us to use sparse representations and sparse computation. Sparse representations reduce the amount of space it takes to save data. As an example, consider the vector:\n",
    "\n",
    "    x = np.array([0, 0, 3, 9, 0, 0, 0, 0, 0, 0])\n",
    "    \n",
    "This vector has 10 values, of which 8 are zero. Storing the vector as above, with zeros, in memory, takes 10 chunks of memory (where a chunk is based on the data type, so likely it would be 32 bits). In contrast, we can *assume* values are zero, and just store the non-zero values, and where they sit on this vector. In pseudo code:\n",
    "\n",
    "    x is a vector with 10 spots, defaulting to zero\n",
    "    there is a 3 at index 2\n",
    "    there is a 9 at index 3\n",
    "    \n",
    "This means we can store this whole vector as something like (again, not real code):\n",
    "\n",
    "    x = sparse_vector([(3, 2), (9, 3)])\n",
    "    \n",
    "Just four numbers, resulting in a saving of 60% of the total memory. This idea also generalises well to higher dimensions (you just record the full co-ordinates). As you might suspect, the actual implementation will be more than 4 numbers, but the general pattern is roughly consistent with this analysis. In short, you should use sparse matrices if you expect more than 60% of the data to be zeros.\n",
    "\n",
    "Additionally, if you know that you are using sparse vectors and matrices, you can use specialised algorithms (both mathematical and computational) that take advantage of this fact. This type of algorithm takes *longer* for dense matrices, but *less time* for sparse matrices. For an example, see the [Sparse PCA](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.SparsePCA.html)\n",
    "\n",
    "\n",
    "#### Exercises\n",
    "\n",
    "1. Run a SparsePCA, RandomizedPCA and (normal) PCA analysis on some data, and compare the explained variance ratio graphs for each.\n",
    "2. Rerun the same analysis on a *very large* dataset, while profiling the result. You can time how long code takes in a Jupyter notebook using the `%time` command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import sklearn as sk\n",
    "from sklearn.decomposition import SparsePCA\n",
    "\n",
    "def my_function():\n",
    "    # A function that takes a while to compute. On my computer, about 11 seconds\n",
    "    time.sleep(1)\n",
    "    j = 0\n",
    "    sparse_pca = SparsePCA(n_components=2)\n",
    "    for i in range(int(10e7)):\n",
    "        sparse_pca.fit(X)\n",
    "        j += i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'X' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "File \u001b[1;32m<timed eval>:1\u001b[0m\n",
      "Cell \u001b[1;32mIn[10], line 11\u001b[0m, in \u001b[0;36mmy_function\u001b[1;34m()\u001b[0m\n\u001b[0;32m      9\u001b[0m sparse_pca \u001b[38;5;241m=\u001b[39m SparsePCA(n_components\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m     10\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mint\u001b[39m(\u001b[38;5;241m10e7\u001b[39m)):\n\u001b[1;32m---> 11\u001b[0m     sparse_pca\u001b[38;5;241m.\u001b[39mfit(\u001b[43mX\u001b[49m)\n\u001b[0;32m     12\u001b[0m     j \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m i\n",
      "\u001b[1;31mNameError\u001b[0m: name 'X' is not defined"
     ]
    }
   ],
   "source": [
    "%time my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Orthogonal representations\n",
    "\n",
    "A mathematical limit of PCA is that it relies on orthogonal transformations of the data. That means that every component will be orthogonal to each other.\n",
    "\n",
    "This is a good \"rule of thumb\" that works well for many datasets, but there are lots of datasets for which this type of transformation doesn't really help. For instance, consider this dataset, created from two different underlying models:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_part_1 = np.arange(100) * 3 + 4 + np.random.random(100) * 50\n",
    "x_part_2 = np.arange(100) * 1.1 - 2 + np.random.random(100) * 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1aa952b4490>]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_part_1, 'ro')\n",
    "plt.plot(x_part_2, 'bo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above dataset, the best transformations would be the lines $3x + 4$ and $1.1x - 2$. However, PCA wouldn't find these lines. It would find the singular line-of-best-fit, and then the best line orthogonal to it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200, 2)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_data = np.hstack([x_part_1, x_part_2])\n",
    "x_data = np.hstack([np.arange(100), np.arange(100)])\n",
    "X = np.vstack([x_data, y_data]).T\n",
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {\n",
       "  /* Definition of color scheme common for light and dark mode */\n",
       "  --sklearn-color-text: black;\n",
       "  --sklearn-color-line: gray;\n",
       "  /* Definition of color scheme for unfitted estimators */\n",
       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
       "  --sklearn-color-unfitted-level-3: chocolate;\n",
       "  /* Definition of color scheme for fitted estimators */\n",
       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
       "\n",
       "  /* Specific color for light theme */\n",
       "  --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
       "  --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));\n",
       "  --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
       "  --sklearn-color-icon: #696969;\n",
       "\n",
       "  @media (prefers-color-scheme: dark) {\n",
       "    /* Redefinition of color scheme for dark theme */\n",
       "    --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
       "    --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));\n",
       "    --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
       "    --sklearn-color-icon: #878787;\n",
       "  }\n",
       "}\n",
       "\n",
       "#sk-container-id-1 {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 pre {\n",
       "  padding: 0;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 input.sk-hidden--visually {\n",
       "  border: 0;\n",
       "  clip: rect(1px 1px 1px 1px);\n",
       "  clip: rect(1px, 1px, 1px, 1px);\n",
       "  height: 1px;\n",
       "  margin: -1px;\n",
       "  overflow: hidden;\n",
       "  padding: 0;\n",
       "  position: absolute;\n",
       "  width: 1px;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-dashed-wrapped {\n",
       "  border: 1px dashed var(--sklearn-color-line);\n",
       "  margin: 0 0.4em 0.5em 0.4em;\n",
       "  box-sizing: border-box;\n",
       "  padding-bottom: 0.4em;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-container {\n",
       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
       "     so we also need the `!important` here to be able to override the\n",
       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
       "  display: inline-block !important;\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-text-repr-fallback {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       "div.sk-parallel-item,\n",
       "div.sk-serial,\n",
       "div.sk-item {\n",
       "  /* draw centered vertical line to link estimators */\n",
       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
       "  background-size: 2px 100%;\n",
       "  background-repeat: no-repeat;\n",
       "  background-position: center center;\n",
       "}\n",
       "\n",
       "/* Parallel-specific style estimator block */\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item::after {\n",
       "  content: \"\";\n",
       "  width: 100%;\n",
       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
       "  flex-grow: 1;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel {\n",
       "  display: flex;\n",
       "  align-items: stretch;\n",
       "  justify-content: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item:first-child::after {\n",
       "  align-self: flex-end;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item:last-child::after {\n",
       "  align-self: flex-start;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item:only-child::after {\n",
       "  width: 0;\n",
       "}\n",
       "\n",
       "/* Serial-specific style estimator block */\n",
       "\n",
       "#sk-container-id-1 div.sk-serial {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "  align-items: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  padding-right: 1em;\n",
       "  padding-left: 1em;\n",
       "}\n",
       "\n",
       "\n",
       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
       "clickable and can be expanded/collapsed.\n",
       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
       "*/\n",
       "\n",
       "/* Pipeline and ColumnTransformer style (default) */\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable {\n",
       "  /* Default theme specific background. It is overwritten whether we have a\n",
       "  specific estimator or a Pipeline/ColumnTransformer */\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "/* Toggleable label */\n",
       "#sk-container-id-1 label.sk-toggleable__label {\n",
       "  cursor: pointer;\n",
       "  display: block;\n",
       "  width: 100%;\n",
       "  margin-bottom: 0;\n",
       "  padding: 0.5em;\n",
       "  box-sizing: border-box;\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 label.sk-toggleable__label-arrow:before {\n",
       "  /* Arrow on the left of the label */\n",
       "  content: \"▸\";\n",
       "  float: left;\n",
       "  margin-right: 0.25em;\n",
       "  color: var(--sklearn-color-icon);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "/* Toggleable content - dropdown */\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content {\n",
       "  max-height: 0;\n",
       "  max-width: 0;\n",
       "  overflow: hidden;\n",
       "  text-align: left;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content pre {\n",
       "  margin: 0.2em;\n",
       "  border-radius: 0.25em;\n",
       "  color: var(--sklearn-color-text);\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content.fitted pre {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
       "  /* Expand drop-down */\n",
       "  max-height: 200px;\n",
       "  max-width: 100%;\n",
       "  overflow: auto;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
       "  content: \"▾\";\n",
       "}\n",
       "\n",
       "/* Pipeline/ColumnTransformer-specific style */\n",
       "\n",
       "#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator-specific style */\n",
       "\n",
       "/* Colorize estimator box */\n",
       "#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-label label.sk-toggleable__label,\n",
       "#sk-container-id-1 div.sk-label label {\n",
       "  /* The background is the default theme color */\n",
       "  color: var(--sklearn-color-text-on-default-background);\n",
       "}\n",
       "\n",
       "/* On hover, darken the color of the background */\n",
       "#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "/* Label box, darken color on hover, fitted */\n",
       "#sk-container-id-1 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator label */\n",
       "\n",
       "#sk-container-id-1 div.sk-label label {\n",
       "  font-family: monospace;\n",
       "  font-weight: bold;\n",
       "  display: inline-block;\n",
       "  line-height: 1.2em;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-label-container {\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       "/* Estimator-specific */\n",
       "#sk-container-id-1 div.sk-estimator {\n",
       "  font-family: monospace;\n",
       "  border: 1px dotted var(--sklearn-color-border-box);\n",
       "  border-radius: 0.25em;\n",
       "  box-sizing: border-box;\n",
       "  margin-bottom: 0.5em;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-estimator.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "/* on hover */\n",
       "#sk-container-id-1 div.sk-estimator:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-estimator.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
       "\n",
       "/* Common style for \"i\" and \"?\" */\n",
       "\n",
       ".sk-estimator-doc-link,\n",
       "a:link.sk-estimator-doc-link,\n",
       "a:visited.sk-estimator-doc-link {\n",
       "  float: right;\n",
       "  font-size: smaller;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  border-radius: 1em;\n",
       "  height: 1em;\n",
       "  width: 1em;\n",
       "  text-decoration: none !important;\n",
       "  margin-left: 1ex;\n",
       "  /* unfitted */\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted,\n",
       "a:link.sk-estimator-doc-link.fitted,\n",
       "a:visited.sk-estimator-doc-link.fitted {\n",
       "  /* fitted */\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "/* Span, style for the box shown on hovering the info icon */\n",
       ".sk-estimator-doc-link span {\n",
       "  display: none;\n",
       "  z-index: 9999;\n",
       "  position: relative;\n",
       "  font-weight: normal;\n",
       "  right: .2ex;\n",
       "  padding: .5ex;\n",
       "  margin: .5ex;\n",
       "  width: min-content;\n",
       "  min-width: 20ex;\n",
       "  max-width: 50ex;\n",
       "  color: var(--sklearn-color-text);\n",
       "  box-shadow: 2pt 2pt 4pt #999;\n",
       "  /* unfitted */\n",
       "  background: var(--sklearn-color-unfitted-level-0);\n",
       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted span {\n",
       "  /* fitted */\n",
       "  background: var(--sklearn-color-fitted-level-0);\n",
       "  border: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link:hover span {\n",
       "  display: block;\n",
       "}\n",
       "\n",
       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
       "\n",
       "#sk-container-id-1 a.estimator_doc_link {\n",
       "  float: right;\n",
       "  font-size: 1rem;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  border-radius: 1rem;\n",
       "  height: 1rem;\n",
       "  width: 1rem;\n",
       "  text-decoration: none;\n",
       "  /* unfitted */\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 a.estimator_doc_link.fitted {\n",
       "  /* fitted */\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "#sk-container-id-1 a.estimator_doc_link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 a.estimator_doc_link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>PCA(n_components=2)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow fitted\">&nbsp;&nbsp;PCA<a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.4/modules/generated/sklearn.decomposition.PCA.html\">?<span>Documentation for PCA</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></label><div class=\"sk-toggleable__content fitted\"><pre>PCA(n_components=2)</pre></div> </div></div></div></div>"
      ],
      "text/plain": [
       "PCA(n_components=2)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "parts_PCA = PCA(n_components=2)\n",
    "parts_PCA.fit(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.25084242,  0.96802793],\n",
       "       [ 0.96802793, -0.25084242]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parts_PCA.components_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(X[:, 0], X[:, 1], 'o', alpha=0.5)\n",
    "for length, vector in zip(parts_PCA.explained_variance_, parts_PCA.components_):\n",
    "    v = vector * 3 * np.sqrt(length)  # The \"3\" just scales so the graph looks good\n",
    "    plt.plot([0, v[0]], [0, v[1]], '-k', lw=3)\n",
    "plt.axis('equal');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the line of best fit for the dots in blue above aren't represented well by this transformation. Instead, you can use other Factor analysis methods to find this type of transformation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variance isn't everything\n",
    "\n",
    "PCA also assumes that the mean and covariance matrices effectively describe the dataset. Many datasets do not following this fact. If your distribution isn't effectively described with a combination of a mean and variance value, then PCA is not going to give you a useful representation of your data. As an example, a Gaussian distribution is *only* defined by its mean and variance. Many distributions have more parameters.\n",
    "\n",
    "Despite this, even if a distribution can't be described with just a mean and variance, a PCA may still provide a useful result.\n",
    "\n",
    "Further to the above, PCA also assumes that *explaining the variance explains the data*. This is a consequence also that PCA is **scale variant**, which causes numbers with higher values and variances to be considered more important than numbers with lower values, even if those lower values are actually more important in the data. A common fix for this is to compute $z-scores$ for each variable, and then compute the PCA on the resulting Z scores instead.\n",
    "\n",
    "\n",
    "### A Linear Assumption\n",
    "\n",
    "PCA also assumes that the best way of looking at your data is as a linear combination of each other. Many relationships have more complicated relationships (log transformations, polynomial, exponent), and PCA cannot account for this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Extended Exercise\n",
    "\n",
    "Download the Quandl dataset \"Capital Market Yields – Government Bonds - Daily\" from Quandl (code `RBA/F02`), compute the change in value per row (diff), and then perform the following steps:\n",
    "\n",
    "1. Split the data into a training set and a testing set. The test set contains the last row of the data. The training set contains all the previous data.\n",
    "2. *With only the training dataset*, fit a PCA model and extract the principle components\n",
    "3. How many principle components are needed to fit at least 99% of the variance in the data?\n",
    "4. Fit a OLS estimator on the lagged data, *for each principle component*. I explain this further below.\n",
    "5. Project the data into the test period, by taking the bias and coefficients of the OLS and predicting the next values.\n",
    "6. Map the projections onto the original data space, by taking the PCA's inverse, to get the actual predicted values\n",
    "7. Calculate the sum of squared error for your predictions.\n",
    "\n",
    "\n",
    "\n",
    "In step 4 above, I ask that we fit an OLS on each principle component. If we have a principle component $C$, we want to use the value $c_{n-1}$ to predict the value $c_{n}$ using the linear equation $c_n = \\beta_0 + \\beta_1 c_{n-1}$. In other words, we fit a linear model saying \"given the a value of this variable in a time series, what is the next value?\". This type of analysis, moving average, will be reviewed further in a future notebook (1.6.1). \n",
    "\n",
    "Solution is in `solutions/PCA Application Example Solution.ipynb`"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
